In many cases, yes! As a start, we'll restrict ourselves for now to symbolic/exact regions and won't concern ourselves with discretizing regions for numerical integrations (though this is possible).

We'll begin by noticing that `RegionConvert` can give us a parametric representation of many regions. For example,
```
RegionConvert[Circle[], "Parametric"]

(* Out: *)

(* ParametricRegion[{{Cos[x], Sin[x]}, 0 <= x <= 2 Pi}, {x}] *)
```
(Those `x`'s are actually `\[FormalX]`s, by the way, but that would just clutter this explanation up.)

Our strategy will simply be to get the tangent information of our region from that function. (It would be nice if Mathematica had built-in ways to extract tangent info—there's a lot of potential for differential geometry here.)

For now, this is our only approach. However, the `"Implicit"` conversion is feasible too, and can handle some cases `"Parametric"` can't. I've set the function up such that this functionality can be added later.
```
(* Helper function for extracting parts of ParametricRegion: *)
ParametricRegionDestructure[
  ParametricRegion[{x_, cons_}, params_]] := {x, cons, params}

(* Make it hold its arguments, and make it look like Integrate on input: *)

SetAttributes[LineIntegrate, HoldAll]
SyntaxInformation[LineIntegrate] = SyntaxInformation[Integrate];


LineIntegrate[v0 : {__}, Element[(vars : {__}), region_?RegionQ]] :=
 
 Module[{
    (* Vector field expression turned into a function: *)
    v = Construct[Function, Unevaluated[vars], Unevaluated[v0]],
    (* variables to hold the region: *)
    regiontype, cregion,
    (* variables to hold the components of a parameterized region: *)
    x, cons, params,
    (* variable to hold the tangent vector to our curve: *)
    tangentVector},
   
   (* The regiontype and cregion are set in the Condition (/;)
      guarding the module expression, so we only ever have to
      compute them once. *)

    Switch[regiontype,
     "Parametric",
     {x, cons, params} = ParametricRegionDestructure[cregion];
     tangentVector = D[x, params];

     (* Apply our vector field to points in the region (x);
     insert params into the integral syntactically *)
     
     With[{f = v @@ x, params0 = params},
      Integrate[
       f . tangentVector, 
       params0 \[Element] ImplicitRegion[cons, params0]]
      ]]

    /; (* Check that RegionConvert succeeded; set variables. *)
    MatchQ[
     cregion = 
      RegionConvert[region, regiontype = "Parametric"],
     _ParametricRegion]

   ] /; (* Also check that our dimensions match up. *)
  Length[Unevaluated[v0]] == Length[Unevaluated[vars]] == 
    RegionEmbeddingDimension[region] && RegionDimension[region] == 1
```
This is just a start. There are a lot of issues:

* No support for the cases where we can't convert to parametric regions—which includes some basic ones (like lines joining multiple points)!

* No way to choose orientation—line integrals are only unique up to a sign, and you may get the opposite sign than the one you bargained for.

* We put a lot of trust in formal variables being definitionless, and also we allow `f` to evaluate fully with those formal variables inside. This could be risky, in part because they *might* have a definition, but mostly because parts of our given expression might evaluate to something undesirable outside of an integral with symbolic arguments—we don't know, and don't want to risk it.

* No error messages yet; it just returns unevaluated. Ideally we should say what's wrong.

* We could generalize to higher dimensions! Why only integrate on curves? (Note that the current implementation supports any embedding dimension, by the way.)

* Mathematica has access to a great curated collection of curves via `SpaceCurve`. These often come with tangent vectors included as properties! We could extend this to use those too—not just regions—but that's pretty straightforward.

As a test, all I have to show you currently is a lowly circle. (Note that the factor of `r^2` is correct: one `r` from the circumference, one `r` from the magnitude of the vector field!)
```
LineIntegrate[{-y, x}, {x, y} \[Element] Circle[{0, 0}, r]]

(* Out: *)
(* 2 Pi r^2 *)
```
And a line, I guess!
```
LineIntegrate[{1, 0, 3}, {x, y, z} \[Element] Line[{{0, 1, 7}, {3, 4, 10}}]]

(* Out: *)

(* 12 *)
```
Hopefully I'll be able to come back to this and extend it.


----------


*Sketch for dealing with implicit regions, to be made explicit when I get the chance:*

* Put the logical expression in disjunctive normal form with `BooleanConvert`

* Separate out all the conjunctions and examine them as regions; keep only the ones that are 1-dimensional (not zero-dimensional); handle each one individually

* Extract the equalit(y/ies) from the conjunction; subtract one side from the other to obtain a list of $n-1$ functions which specify the curve as their mutual zero set (such that the other constraints in the conjunction hold), $n$ the embedding dimension

* Look at the gradients of these functions and use those to "project off" components of our vector field at each point until only the part pointing along the curve remains, then integrate the norm over the region (corresponding to the full conjunction at hand) and see if Mathematica likes it. (This can't be right—we're at least missing orientation. But maybe I can make something similar work.) Add together the results.

* If not, try using `DSolve` somehow...