sharjeelyunus/github-issues-dataset huggingface dataset:
Repository: rust
Issue: Function missing PartialEq when type not explicitly annotated
Labels: A-type-system,T-compiler,T-types

Suppose we have an extern function foo for use in FFI. For some reason an explicit type annotation allows use of the PartialEq trait, but no type annotation does not (even though the error message states the type is identical: `unsafe extern "C" fn() -> i32 {foo}`):

```rust
#[no_mangle]
pub unsafe extern "C" fn foo() -> i32 { return 1; }
fn main() {
    let mut fn_ptr: unsafe extern "C" fn() -> i32 = foo;
    let mut fn_ptr2 = foo;
    
    fn_ptr == fn_ptr; // Ok
    fn_ptr2 == fn_ptr2; // Err
}
```

Which errors with:
```shell
error[E0369]: binary operation `==` cannot be applied to type `unsafe extern "C" fn() -> i32 {foo}`
 --> src/main.rs:8:5
  |
8 |     fn_ptr2 == fn_ptr2; // Err
  |     ^^^^^^^^^^^^^^^^^^
  |
  = note: an implementation of `std::cmp::PartialEq` might be missing for `unsafe extern "C" fn() -> i32 {foo}`
```
Repository: go
Issue: encoding/asn1: error when unmarshalling SEQUENCE OF SET
Labels: NeedsInvestigation


### What version of Go are you using (`go version`)?
go1.11 windows/amd64

### Does this issue reproduce with the latest release?
Yes

### What operating system and processor architecture are you using (`go env`)?
```
set GOARCH=amd64
set GOBIN=
set GOCACHE=C:\Users\xxx\AppData\Local\go-build
set GOEXE=.exe
set GOFLAGS=
set GOHOSTARCH=amd64
set GOHOSTOS=windows
set GOOS=windows
set GOPATH=C:\dev;C:\gopath
set GOPROXY=
set GORACE=
set GOROOT=C:\Go
set GOTMPDIR=
set GOTOOLDIR=C:\Go\pkg\tool\windows_amd64
set GCCGO=gccgo
set CC=gcc
set CXX=g++
set CGO_ENABLED=1
set GOMOD=
set CGO_CFLAGS=-g -O2
set CGO_CPPFLAGS=
set CGO_CXXFLAGS=-g -O2
set CGO_FFLAGS=-g -O2
set CGO_LDFLAGS=-g -O2
set PKG_CONFIG=pkg-config
set GOGCCFLAGS=-m64 -mthreads -fmessage-length=0 -fdebug-prefix-map=C:\Users\xxx\AppData\Local\Temp\go-build551125774=/tmp/go-build -gno-rec
ord-gcc-switches
```

### What did you do?
```golang
package main

import (
	"encoding/asn1"
	"fmt"
)

//` schema:
//
//	World-Schema DEFINITIONS AUTOMATIC TAGS ::=
//	BEGIN
//	SomeStruct ::= SEQUENCE
//	{
//		id      INTEGER,
//		field1  SEQUENCE OF SomeSet
//	}
//	SomeSet ::= SET
//	{
//		field2 INTEGER
//	}
//	END
//`

// data
//	{
//		"id":1,
//		"field1": [{"field2": 1}, {"field2": 2}]
//	}

// encode with http://asn1-playground.oss.com/
const encodedDer = "\x30\x0F\x80\x01\x01\xA1\x0A\x31\x03\x80\x01\x01\x31\x03\x80\x01\x02"

type SomeStruct struct {
	ID int `asn1:"tag:0"`
	SomeSetSlice []SomeSet `asn1:"tag:1,set"`
}

type SomeSet struct {
	Field2 int `asn1:"tag:0"`
}

func main() {
	var b SomeStruct
	_, err := asn1.Unmarshal([]byte(encodedDer), &b)
	if err != nil {
		panic(err)
	}
	fmt.Println(b)
}
```
play link:
https://play.golang.org/p/V-za5Cu1wkr

### What did you expect to see?
SEQUENCE OF SET should be properly unmarshalled into a slice of structs. [Documentation](https://golang.org/pkg/encoding/asn1/#Unmarshal) says that SET can be unmarshalled into a struct. So I believe a SEQUENCE OF SET is expected to be properly unmarshalled into a slice of structs.

### What did you see instead?

asn1: structure error: sequence tag mismatch.

The problem might be in [getUniversalTag](https://github.com/golang/go/blob/579768e0785f14032e3a971ad03f2deb33427e2d/src/encoding/asn1/common.go#L168) function when it is called from `parseSequenceOf`. E.g. 

```golang
	case reflect.Struct:
		return false, TagSequence, true, true
```
When struct is an element of slice there is no possibility to tag a struct as a SET (17) , it's always tagged as a SEQUENCE (16).
Repository: rust
Issue: Show a suggestion after the compiler fails when you implement `from` and forget to mark as `pub`
Labels: A-diagnostics,A-trait-system,A-visibility,T-compiler,C-feature-request,D-confusing,D-terse

Let say we have a `main.rs` like this ...

```rust
use std::io::{self, Write};
use std::process::Command;

mod cmd;
mod error;

use cmd::Cmd;
use error::Error;

fn main() -> Result<(), io::Error> {
    let stdin = io::stdin();
    let mut stdout = io::stdout();

    loop {
        let mut line = String::new();
        print!("> ");
        stdout.flush()?;
        stdin.read_line(&mut line)?;

        match Cmd::from(&line) {
            Ok(cmd) => {
                let output = Command::new(cmd.binary).args(cmd.args).output()?;
                print!("{}", String::from_utf8_lossy(&output.stdout));
            }
            Err(Error::NoBinary) => {}
        }
    }
}
```

an `error.rs` like this ...

```rust
#[derive(Debug)]
pub enum Error {
    NoBinary,
}
```

and `cmd.rs` like this ...

```rust
use error::Error;

// A command consists of a binary and its arguments
pub struct Cmd<'a> {
    pub binary: &'a str,
    args: Vec<&'a str>,
}

impl<'a> Cmd<'a> {
    // Extract the command and its arguments from the commandline
    fn from(line: &'a str) -> Result<Self, Error> {
        let mut parts = line.split_whitespace();
        let binary = parts.nth(0).ok_or_else(|| Error::NoBinary)?;
        let args = parts.collect();

        Ok(Cmd { binary, args })
    }
}
```

If you try to compile this you get the following error ...

```
error[E0308]: mismatched types
  --> src/main.rs:20:25
   |
20 |         match Cmd::from(&line) {
   |                         ^^^^^ expected struct `cmd::Cmd`, found reference
   |
   = note: expected type `cmd::Cmd<'_>`
              found type `&std::string::String`

error[E0308]: mismatched types
  --> src/main.rs:21:13
   |
21 |             Ok(cmd) => {
   |             ^^^^^^^ expected struct `cmd::Cmd`, found enum `std::result::Result`
   |
   = note: expected type `cmd::Cmd<'_>`
              found type `std::result::Result<_, _>`

error[E0308]: mismatched types
  --> src/main.rs:25:13
   |
25 |             Err(Error::NoBinary) => {}
   |             ^^^^^^^^^^^^^^^^^^^^ expected struct `cmd::Cmd`, found enum `std::result::Result`
   |
   = note: expected type `cmd::Cmd<'_>`
              found type `std::result::Result<_, _>`
```

The code is wrong because the `from` fn is not `pub`. As soon as you mark it as `pub` everything works as expected.
The problem is that I'd expect a mention in the error report that the `from` considered by the compiler is not the one you're trying to call. It's just that you forgot to mark the fn as `pub`.
Repository: flutter
Issue: Describe CupertinoColor provenance
Labels: framework,f: cupertino,d: api docs,P2,team-design,triaged-design

For each entry, describe how it was derived.

At the top of the file, have a ordered list of preferred means of getting these values. 

1- Apple design Sketch file
2- Third-party design Sketch file
3- Color picker from simulator
4- Eyeballing
Repository: rust
Issue: improve error message when returning iterator with reference into stack frame 
Labels: C-enhancement,A-diagnostics,T-compiler

This example ([playground](https://play.rust-lang.org/?gist=dbf25e623505ebbb9a118b9155107fbc&version=stable&mode=debug&edition=2015)):

```rust
use std::rc::Rc;

fn iterate(data: Rc<Vec<u32>>) -> impl Iterator<Item = u32> {
    data.iter().cloned()
}

fn main() {
    for x in iterate(Rc::new(vec![1, 2, 3])) {
        println!("Hi! {}", x);
    }
}
```

gives this error:

```
error[E0597]: `data` would be dropped while still borrowed
 --> src/main.rs:4:5
   |
 4 |     data.iter().cloned()
   |     ^^^^ borrowed value does not live long enough
 5 | }
   | - borrowed value only lives until here
   |
   = note: borrowed value must be valid for the static lifetime...
```

I think we could do better. For example, we don't explain anything about how `impl Iterator` disallows lifetimes; and I think we can clarify *why* `data is being dropped.

I don't yet have a concrete suggestion, though, have to think about it.

Related to https://github.com/rust-lang/rust/issues/52534 -- in some sense a specific instance of that.
Repository: opencv
Issue: Test: Fix build information from tests on Windows platform (MSBuild)
Labels: bug,test

related #12067 

CMake with MSBuild generator doesn't fill "Configuration" value.
Debug/Release build type is defined via compilation parameters.

```
Build type: N/A
WARNING: build value differs from runtime: Release
```
Repository: rust
Issue: Provide a split method which doesn't consume the element used to split
Labels: T-libs-api,C-feature-request

The [split](https://doc.rust-lang.org/std/primitive.slice.html#method.split) method consumes the element used to split, how you can see in the code below. But in some cases would be nice to move the element to the "first or second slice" like the [split_at](https://doc.rust-lang.org/std/primitive.slice.html#method.split_at) method does, but to **n** slices.

The numpy library has a [method ](https://docs.scipy.org/doc/numpy/reference/generated/numpy.split.html)like that.

https://play.rust-lang.org/?gist=94dd413054604e4efffa96a5e8ed72b5&version=stable&mode=debug&edition=2015

**Code**
```rust
#[derive(Clone, Debug)]
struct Delta {
    pub val: i32
}

fn main() {
    let mut v = vec![Delta{ val: 1 }, Delta{ val: 5 }, Delta{ val: 1 }];
    
    let new_v : Vec<Vec<Delta>> = v.split(|x| x.val > 4)
                    .into_iter()
                    .map(|x| x.to_vec())
                    .collect();
                    
    println!("{:?}", new_v);
}
```
**Output**
```
[[Delta { val: 1 }], [Delta { val: 1 }]]
```

**New Split Method1 Output**
```
[[Delta { val: 1 }, Delta { val: 5 }], [Delta { val: 1 }]]
```

**New Split Method2 Output**
```
[[Delta { val: 1 }], [Delta { val: 5 }, Delta { val: 1 }]]
```
Repository: pytorch
Issue: A Caffe2 Implementation of Pose Estimation
Labels: caffe2

Hi, I would like to provide a link for a caffe2 implementation of human pose estimation at here. The link is at: https://github.com/eddieyi/caffe2-pose-estimation .
Thanks.
Repository: go
Issue: crypto/sha1: add native SHA1 instruction implementation for AMD64
Labels: Performance,NeedsDecision

I've transliterated the [Linux kernel](https://github.com/torvalds/linux/blob/master/arch/x86/crypto/sha1_ni_asm.S) version of native SHA1 instructions to [Go's flavor of assembly](https://gist.githubusercontent.com/BenLubar/d11e801907892a6ee8d7ce1e0e4db144/raw/sha1block_amd64.s). The result is a [1.5x to 3x speed-up](https://gist.github.com/BenLubar/d11e801907892a6ee8d7ce1e0e4db144/raw/70a5cee937d0bfff056497718d924613f1f11e32/cmp.txt) on my Ryzen 5 1600. Could this be included in Go, similar to the AVX2 implementation that is already in crypto/sha1?
Repository: vue-element-admin
Issue: 左侧侧边栏页面DOM结构异常 - use fragment
Labels: feature

<img width="1043" alt="2018-09-02 3 53 17" src="https://user-images.githubusercontent.com/23553358/44953799-0a590380-aecb-11e8-9fcc-f9d1b9d820d5.png">
Repository: javascript-algorithms
Issue: Suggestion: ship production ready build to npm
Labels: enhancement

Hey,

I noticed that the current version deployed on npm (i.e. https://www.npmjs.com/package/javascript-algorithms-and-data-structures) is more or less a mirror of the source code here. `javascript-algorithms` is really awesome and someone might want to use it as an external library on production (e.g. a web app or node app). Unfortunately, the use of ES modules, complicates things a bit.

May I suggest:
1. Transpiling code to ES2015, using CommonJS instead of ES modules;
2. Removing redundant source code (e.g. comments, README, etc) to reduce package size.

I'd be more that willing to provide a PR using rollup + babel.
Repository: TypeScript
Issue: Input source maps
Labels: Suggestion,Awaiting More Feedback

## Suggestion

Support input source maps, for the case where a TS file is generated programatically from some other source file, in order to permit end-to-end mapping.

Such source maps could either be specified in the `.ts` file using the `//# SourceMappingURL=foo.ts.map` notation, searched for under the name `*.ts.map`, or found in-line in the `.ts` sources, etc., depending on various options.

The effect would be that the `*.js.map` file generated (or inlined) would be the equivalent of what is known as "applying" the input source map to the tsc-generated sourcemap. In other words, the sourcemap would map lines in the `*.js` file all the way back to the original file(s) from which the `*.ts` file was generated.

## Use Cases

This issue has come up in the context of some literate programming hacking I am doing. The programmer works on "literate programming documents" (actually, a flavor of Markdown), and then "tangles" (to use Knuth's terminology) that into a TS file.

My tangler generates the `*.ts.map` file. Currently, what I am doing is to provide an extra utility which the programmer can use to "apply" the map I create to the one created by `tsc` to get lines in the `*.js` all the way back to the literate programming document. However, this is a bit clumsy, and requires some setup. It would be nicer if `tsc` could take in source maps, apply them itself, and output `*.js.map` files reflecting that mapping.

## Examples

Currently, the user does something like the following:

    modernlit --sourcemap foo.lit.md # creates foo.ts and foo.ts.map
    tsc --sourcemap foo.ts # creates foo.js and foo.js.map
    mlsourcemap foo.ts.map foo.js.map # rewrites foo.js.map by "applying" foo.ts.map

("modernlit" is the name I am currently using for my literate programming system.)

With the feature I am proposing, the call to `mlsourcemap` could be eliminated. `tsc` would find `foo.ts.map`, and perform the mapping, generating a `foo.js.map` which reflected it having been "applied" to the JS-to-TS sourcemap. This would avoid the user having to remember to call `mlsourcemap`, and avoid me having to write it, maintain, and document it.

For information on "applying" (remapping) sourcemaps, as implemented in the Mozilla source-maps library, see [here](https://github.com/mozilla/source-map#sourcemapgeneratorprototypeapplysourcemapsourcemapconsumer-sourcefile-sourcemappath).

## Checklist

My suggestion meets these guidelines:
* [x] This wouldn't be a breaking change in existing TypeScript / JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. new expression-level syntax)
Repository: rust
Issue: Unhelpful help for E0387 "consider changing this closure to take self by mutable reference"
Labels: C-enhancement,A-diagnostics,T-compiler,A-suggestion-diagnostics,D-invalid-suggestion

I just got this error message (on current stable, beta, and the nightly mentioned below):

```plain
error[E0387]: cannot borrow data mutably in a captured outer variable in an `Fn` closure
  --> src/main.rs:30:57
   |
30 |         .for_each(|filename| tally_words(filename, &mut words).unwrap());
   |                                                         ^^^^^
   |
help: consider changing this closure to take self by mutable reference
  --> src/main.rs:30:19
   |
30 |         .for_each(|filename| tally_words(filename, &mut words).unwrap());
   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
```

As you can see it suggests to do no change at all:

```diff
-          .for_each(|filename| tally_words(filename, &mut words).unwrap());
+          .for_each(|filename| tally_words(filename, &mut words).unwrap());
```

You can reproduce this by checking out <https://github.com/hello-rust/show/pull/45/commits/d495abe606d7f4111c7d2535bb6808c212817865> and running `cd episode/9/rust/pascal/; cargo build`.

<details>
<summary>Rust version</summary>
<pre><code>rustc 1.30.0-nightly (f8d34596f 2018-08-30)
binary: rustc
commit-hash: f8d34596ff74da91e0877212a9979cb9ca13eb7e
commit-date: 2018-08-30
host: x86_64-apple-darwin
release: 1.30.0-nightly
LLVM version: 7.0</code></pre>
</details>
Repository: go
Issue: cmd/compile: autotemps can make stack frame too large
Labels: NeedsFix,compiler/runtime

When the order pass introduces temporaries, it always allocates them on the stack, even if they are too big for the stack.

```
package main

import "reflect"

func f() {
	g(reflect.TypeOf([2000000000]*byte{}))
}

//go:noescape
func g(p reflect.Type)
```

We should use the same rules as escape analysis does to decide if we should put the temporary on the stack or the heap.

Before order:
```
.   .   .   AS2-list
.   .   .   .   NAME-reflect.i a(true) l(1376) x(0) class(PAUTO) tc(1) addrtaken assigned used INTER-interface {}
.   .   .   AS2-rlist
.   .   .   .   CONVIFACE l(6) esc(no) tc(1) implicit(true) INTER-interface {}
.   .   .   .   .   ARRAYLIT l(6) esc(h) tc(1) ARRAY-[2000000000]*byte
```
After order:
```
.   AS l(6) tc(1)
.   .   NAME-main..autotmp_5 a(true) l(6) x(0) class(PAUTO) esc(N) tc(1) assigned used ARRAY-[2000000000]*byte
.   .   ARRAYLIT l(6) esc(h) tc(1) ARRAY-[2000000000]*byte

.   AS2 l(6) tc(1)
.   AS2-list
.   .   NAME-reflect.i a(true) l(1376) x(0) class(PAUTO) tc(1) addrtaken assigned used INTER-interface {}
.   AS2-rlist
.   .   CONVIFACE l(6) esc(no) tc(1) implicit(true) INTER-interface {}
.   .   .   NAME-main..autotmp_5 a(true) l(6) x(0) class(PAUTO) esc(N) tc(1) assigned used ARRAY-[2000000000]*byte

.   VARKILL l(6) tc(1)
.   .   NAME-main..autotmp_5 a(true) l(6) x(0) class(PAUTO) esc(N) tc(1) assigned used ARRAY-[2000000000]*byte
```
Repository: flutter
Issue: FR: add .of() method to RenderBox
Labels: c: new feature,framework,P3,team-framework,triaged-framework

Currently we have to do this

`(context.findRenderObject() as RenderBox).size.height`

It would be nice to be able to do this:

`RenderObject.of(context).size.height`

Which matches the semantics of MediaQuery

`MediaQuery.of(context).size.height`
Repository: TypeScript
Issue: Type narrowing not working as expected in else
Labels: Suggestion,In Discussion

For the following code with `strictNullChecks` enabled:

```ts
interface Base {
    a: {} | null;
    b: {} | null;
}

function test(base: Base): void {
    if (!base.a && !base.b) {
        const result: null = null;
    } else if (!base.a && base.b) {
        const result: {} = base.b;
    } else if (base.a && !base.b) {
        const result: {} = base.a;
    } else {
        const result: {} = base.b;
    }
}
```

I'm seeing this error on the last result:

```
Type '{} | null' is not assignable to type '{}'.
  Type 'null' is not assignable to type '{}'.
```

I expect it to work as the else implies:

```
   !(!base.a && !base.b) && !(!base.a && base.b) && !(base.a && !base.b) 
 = (base.a || base.b) && (base.a || !base.b) && (!base.a || base.b)
 = (base.a || base.b) && (base.a) && (base.b)
      note: !base.b and !base.a are canceled out as the expression cannot be true if one
            of them is false
 = base.a && base.b
```

[TS play link](http://www.typescriptlang.org/play/#src=interface%20Base%20%7B%0D%0A%20%20%20%20a%3A%20%7B%7D%20%7C%20null%3B%0D%0A%20%20%20%20b%3A%20%7B%7D%20%7C%20null%3B%0D%0A%7D%0D%0A%0D%0Afunction%20test(base%3A%20Base)%3A%20void%20%7B%0D%0A%20%20%20%20if%20(!base.a%20%26%26%20!base.b)%20%7B%0D%0A%20%20%20%20%20%20%20%20const%20result%3A%20null%20%3D%20null%3B%0D%0A%20%20%20%20%7D%20else%20if%20(!base.a%20%26%26%20base.b)%20%7B%0D%0A%20%20%20%20%20%20%20%20const%20result%3A%20%7B%7D%20%3D%20base.b%3B%0D%0A%20%20%20%20%7D%20else%20if%20(base.a%20%26%26%20!base.b)%20%7B%0D%0A%20%20%20%20%20%20%20%20const%20result%3A%20%7B%7D%20%3D%20base.a%3B%0D%0A%20%20%20%20%7D%20else%20%7B%0D%0A%20%20%20%20%20%20%20%20const%20result%3A%20%7B%7D%20%3D%20base.b%3B%0D%0A%20%20%20%20%7D%0D%0A%7D)
Repository: bitcoin
Issue: rpc: Wrong `gettransaction` info for a coinjoin
Labels: RPC/REST/ZMQ

Take a look at this transaction:

https://testnet.smartbit.com.au/tx/947ddb7d22b0c7e8edd3a56a92b8ec771aa8b18667ef508270f928b14821e924

I've double checked with `getaddressinfo` and only the first input is mine, and the second output is mine. So the transaction looks like


Inputs: [1.02 BTC mine,  1.1 BTC not-mine]
Outputs:  [0.10481803 BTC not-mine, 2.01 BTC mine]


So clearly this transaction makes me  0.99 BTC richer.  (-1.02 + 2.01)

So now let's look at what `gettransaction` returns:

```
{
  "amount": -0.10481803,
  "fee": 1.09481803,
  "confirmations": 0,
  "trusted": false,
  "txid": "947ddb7d22b0c7e8edd3a56a92b8ec771aa8b18667ef508270f928b14821e924",
  "walletconflicts": [
  ],
  "time": 1535929790,
  "timereceived": 1535929790,
  "bip125-replaceable": "no",
  "details": [
    {
      "address": "2N8qCRsKMJ3qNYo8LRb9kLpy3qiigAuedMT",
      "category": "send",
      "amount": -0.10481803,
      "vout": 0,
      "fee": 1.09481803,
      "abandoned": false
    },
    {
      "address": "2MzFcfPF56Jp6BC3FJk6yXwCY6FzhnbGt3o",
      "category": "send",
      "amount": -2.01000000,
      "label": "",
      "vout": 1,
      "fee": 1.09481803,
      "abandoned": false
    },
    {
      "address": "2MzFcfPF56Jp6BC3FJk6yXwCY6FzhnbGt3o",
      "category": "receive",
      "amount": 2.01000000,
      "label": "",
      "vout": 1
    }
  ],
  "hex": "020000000001022eb1b5698216f56eea3770c949a5d9555dcd1062571cc3113cae68132a5ba5660100000017160014f67a19d36a915d7e0360d3a66d1f055c7bd34687feffffffe165f072311e71825b47a4797221d7ae56d4b40b7707c540049aee43302448a401000000171600142fa1c410210f8228467e53f450c9e4e56337895ffeffffff028bf09f000000000017a914aaf6ba68cf6a2369445f119596adb84412d28d3a874004fb0b0000000017a9144cdbced31bab78d8a248204a961a4ad475d6b48a87024730440220724dbbdc278315ed367036b163749702c7810730dc2b17ba3226f72c7d0078ab02207945ffb8ffc78bcefa207ac8e172983b5c3d91f64c3cb869cdcd288e6c1d85610121037426b52590172ce72df80829e4a9f7530224306399c399080fc917d19ae44a72024730440220168c025d48f3ee4d626d37a85c92a75e778649e966d8f008caeed688cb6da73902202e00fb70c80e0ba591a12a8feb067cf3216eb054ac5059d0f38ce805bbdd478701210213be1638b4620ccacf4e1bec9748c3fc27561aa7169dbd1639be00bb20236ab800000000"
}
```

Note the "fee" thing it has is pretty confused. The actual fee is: 0.00518197 BTC




Running on the 0.17   branch if it makes a difference.
Repository: pytorch
Issue: [Caffe2] How to correctly add Caffe2 libraries to Visual Studio to write C++ programs?
Labels: caffe2

Hello all,

I successfully built Caffe2 from source on windows 10. Now, I would like to use caffe2 libraries in Visual Studio 2015 to write C++ programs. **How should I add the libraries and from what path in order to be able to include the libraries as below?**
```
#include "caffe2/core/common.h"
#include "caffe2/utils/proto_utils.h"
#include "caffe2/core/workspace.h"
#include "caffe2/core/tensor.h"
#include "caffe2/core/init.h"
```

Should I add only these libraries?

![image](https://user-images.githubusercontent.com/25825048/44961661-2ed9cd80-af15-11e8-8621-d99fdc1bfa9d.png)

I followed this guide https://caffe2.ai/docs/cplusplus_tutorial.html . I added the following directories in Visual Studio:
D:\Yeverino\git_projects\pytorch\build\lib\Release
D:\Yeverino\git_projects\pytorch\build\caffe2\proto\Caffe2_PROTO.dir\Release
D:\Yeverino\git_projects\pytorch\caffe2\cuda_rtc\core
D:\Yeverino\git_projects\pytorch\caffe2\proto
D:\Yeverino\git_projects\pytorch\build
D:\Yeverino\git_projects\pytorch\build\caffe2

![image](https://user-images.githubusercontent.com/25825048/44974444-f6131600-af5f-11e8-9437-2ab1f32f736f.png)

However, I got errors like below when I tried to include #include <blob.h> in a project:
`Error	C1083	Cannot open include file: 'caffe2/core/common.h': No such file or directory	ConsoleApplication1	D:\Yeverino\git_projects\pytorch\caffe2\cuda_rtc\core\blob.h	11	`

Once I changed `#include "caffe2/core/blob_serializer_base.h"` to `#include "blob_serializer_base.h"`, error was fixed and other similar errors were detected due to the prefix "caffe2/$package/" in the includes. I really want to avoid renaming all includes.